/*
 * 智能学习
 * */

import http from '@/utils/http';

// 未知问题 列表
export async function unknownQuestionsList(params) {
  return http.post('/learn/wait/ques/unknownQuestionList', params);
  // return http.post('/basic/learn-question/unknownQuestionPage', params);
}

// 未知问题 忽略/恢复
export async function ignoreUnknownQuestion(params) {
  return http.post('/learn/wait/ques/ignore', params);
}

// 未知问题 批量忽略
export async function ignoreUnknownQuestions(params) {
  return http.post('/learn/wait/ques/ignore', params);
  // return http.post('/basic/learn-question/ignoreUnknownQuestion', params);
}

// 未知问题 批量恢复
export async function recoveryUnknownQuestions(params) {
  return http.post('/learn/wait/ques/ignore', params);
  // return http.post('/basic/learn-question/recoveryUnknownQuestion', params);
}

// 未知问题/未解决问题/转人工问题 聊天上下文
export async function toChatContextJson(params) {
  return http.post('/stat/toChatContextJson', params);
}

// 待学习问题 - 未知/未解决/转人工 - 会话记录
export async function getSessionList(params) {
  return http.post('/learn/wait/ques/questionList', params);
}

//  未解决问题 列表
export async function unresolvedQuestionsJson(params) {
  return http.post('/learn/wait/ques/unresolvedQuestionsList', params);
}

// 未解决问题 忽略/恢复
export async function ignoreUnresolvedQuestion(params) {
  return http.post('/learn/wait/ques/ignore', params);
}

// 未解决问题 批量忽略/恢复
export async function ignoreUnresolvedQuestions(params) {
  return http.post('/learn/wait/ques/ignore', params);
}

// 转人工问题 列表
export async function askHumanRecordsJson(params) {
  return http.post('/learn/wait/ques/askHumanQuestionList', params);
}

// 转人工问题 忽略/恢复
export async function ignoreHumanRecord(params) {
  return http.post('/stat/ignoreHumanRecord', params);
}

// 转人工问题 批量忽略/恢复
export async function ignoreHumanRecordBatch(params) {
  return http.post('/learn/wait/ques/ignoreHumanRecordBatch', params);
}

// 转人工问题 批量忽略/恢复ss
export async function linkBoxJson(params) {
  return http.post('/learn/wait/ques/relation/question', params);
}

// 模型生成 列表
export async function gptQuestionsJson(params) {
  return http.post('/learn/wait/ques/gptQuestionList', params);
}

// 模型生成 忽略/恢复
export async function ignoreGptQuestion(params) {
  return http.post('/learn/wait/ques/ignore', params);
}

// 模型生成 批量忽略/恢复
export async function ignoreGptQuestions(params) {
  return http.post('/learn/wait/ques/ignore', params);
}

// 文档问答 列表
export async function docQuestionsJson(params) {
  return http.post('/learn/wait/ques/docQuestionList', params);
}

// 文档问答 忽略/恢复
export async function ignoreDocQuestion(params) {
  return http.post('/learn/wait/ques/ignore', params);
}

// 文档问答 批量忽略/恢复
export async function ignoreDocQuestions(params) {
  return http.post('/learn/wait/ques/ignore', params);
}

// 问答记录 -- 关联列表 --关联知识点
export async function fakeAnswerRelevanceknowledgeData(params) {
  return http.post('//stat/qa/record/relationQa', params);
}

// 问答记录 -- 关联上下文
export async function UpDownData(params) {
  return http.post('/stat/listSessionChatsJson', params);
}

// 业务词库 导出业务词
export async function dcexport(params) {
  return http.post('/learn/wait/ques/relationWaitLearnQa', params);
}

// 未知问题导出
export async function exportWz(params) {
  return http.downloadFileForPostWithCallBack('/learn/wait/ques/export', params);
}

// 未解决问题导出
export async function dcexportWj(params) {
  return http.downloadFileForPostWithCallBack('/learn/wait/ques/export', params);
}

// 装人问题导出
export async function dcexportRg(params) {
  return http.downloadFile('/learn/wait/ques/askHuman/export', params);
}

/*
 * 知识库体检
 * */

// 知识库体检 获取体检数据
export async function examinationData(params) {
  return http.get('/learn/knowledge/examine/check/info', params);
}

// 知识库体检 重新检测
export async function retest(params) {
  return http.post('/learn/knowledge/examine/check/submit', params);
}

// 知识库体验 相似问列表
export async function similarAskList(params) {
  return http.postFormData('/learn/knowledge/examine/similar/list', params);
}

// 知识库体验 删除相似问
export async function deleteSimilarQuestions(params) {
  return http.get('/learn/knowledge/examine/similar/delete', params);
}

// 知识库体验 移动相似问
export async function movingSimilarQuestions(params) {
  return http.postFormData('/learn/knowledge/examine/similar/move', params);
}

// 忽略/恢复相似问
export async function ignoreSimilarQue(params) {
  return http.get('/learn/knowledge/examine/similar/ignore', params);
}

// 全部 忽略/恢复相似问
export async function allIgnoreSimilarQue(params) {
  return http.get('/learn/knowledge/examine/similar/allIgnore', params);
}

// 知识库体检 获取体检进度
export async function knowledgeExamineCheckProcess(params) {
  return http.get('/learn/knowledge/examine/check/process', params);
}

// 知识库体检 获取体检任务状态
export async function getTaskInfo(params) {
  return http.get('/learn/knowledge/examine/check/getTaskInfo', params);
}

/*
 * 异常问页面
 * */

// 知识库体验 异常问列表
export async function getAbnormalList(params) {
  return http.postFormData('/learn/knowledge/examine/abnormal/list', params);
}

// 知识库体验 忽略/恢复异常问
export async function ignoreAbnormalQuestion(params) {
  return http.get('/learn/knowledge/examine/abnormal/ignore', params);
}

// 知识库体验 全部 忽略/恢复异常问
export async function allIgnoreAbnormalQuestion(params) {
  return http.get('/learn/knowledge/examine/abnormal/allIgnore', params);
}

// 知识库体验 删除异常问
export async function deleteAbnormalQuestion(params) {
  return http.get('/learn/knowledge/examine/abnormal/delete', params);
}

// 待学习问题 关联知识点
export async function relationWaitLearnQa(params) {
  return http.post('/learn/wait/ques/relationWaitLearnQa', params);
}

// 知识库体验 关联异常问
export async function addToOtherQa(params) {
  return http.get('/learn/knowledge/examine/abnormal/relation', params);
}

// 问答记录 -- 关联列表
export async function fakeAnswerRelevanceData(params) {
  return http.get('/relQaQa/aiLearning/list', params);
}

// 知识库体验 获取相似问、异常问任务状态
export async function knowledgeExamineCheckStatus(params) {
  return http.post('/learn/knowledge/examine/check/status', params);
}

/*
 * 知识库智能维护
 * */

// 知识库智能维护 导入未知问题
export async function importUnknownProblem(params) {
  return http.post('/learn/knowledge/maintain/unknown/import', params);
}

// 知识库智能维护 导入转人工问题
export async function importArtificialProblem(params) {
  return http.post('/learn/knowledge/maintain/askHuman/import', params);
}

// 知识库智能维护 导入未解决问题
export async function importUnresolvedProblem(params) {
  return http.post('/learn/knowledge/maintain/unresolved/import', params);
}

// 知识库智能维护 问题库列表
export async function knowledgeQuestionList(params) {
  return http.post('/learn/knowledge/question/list', params);
}

// 知识库智能维护 获取最近的导入记录
export async function maintainImportRecord(params) {
  return http.get('/learn/knowledge/maintain/import/record', params);
}

// 知识库智能维护 问题库黑名单列表
export async function knowledgeBlacklistList(params) {
  return http.post('/learn/knowledge/blacklist/list', params);
}

// 知识库智能维护 问题库 移到黑名单
export async function questionBlacklistMoveIn(params) {
  return http.post('/learn/knowledge/question/blacklist/moveIn', params);
}

// 知识库智能维护 黑名单 移出黑名单
export async function knowledgeBlacklistMoveOut(params) {
  return http.post('/learn/knowledge/blacklist/moveOut', params);
}

// 知识库智能维护 删除问题库中的问题
export async function knowledgeQuestionDelete(params) {
  return http.post('/learn/knowledge/question/delete', params);
}

// 知识库智能维护 获取导入总数
export async function knowledgeMaintainImportTotal(params) {
  return http.get('/learn/knowledge/maintain/import/total', params);
}

// 知识库智能维护 获取问题推荐状态
export async function maintainRecommendStatus(params) {
  return http.get('/learn/knowledge/maintain/recommend/status', params);
}

// 知识库智能维护 获取问题聚类状态
export async function knowledgeMaintainClusterStatus(params) {
  return http.get('/learn/knowledge/maintain/cluster/status', params);
}

// 知识库智能维护 自定义问题导入模版
export async function knowledgeMaintainImportTemplate(params) {
  return http.get('/learn/knowledge/maintain/import/template', params);
}

// 知识库智能维护 导入自定义问题
export async function knowledgeMaintainImport(params) {
  return http.post('/learn/knowledge/maintain/import', params);
}

// 知识库智能维护 开始推荐问题推荐任务
export async function knowledgerecommendSubmit(params) {
  return http.post('/learn/knowledge/recommend/submit', params);
}

// 知识库智能维护 开始聚类问题聚类任务
export async function knowledclusterSubmit(params) {
  return http.post('/learn/knowledge/cluster/submit', params);
}

// 知识库智能维护 问题推荐列表
export async function knowledgeRecommendList(params) {
  return http.post('/learn/knowledge/recommend/list', params);
}

// 知识库智能维护 问题聚类列表 ---
export async function knowledgeRecommendListB(params) {
  return http.post('/learn/knowledge/cluster/list', params);
}

// 知识库智能维护 问题推荐批量删除
export async function knowledgeRecommendIgnore(params) {
  return http.post('/learn/knowledge/recommend/delete', params);
}

// 知识库智能维护问题聚类批量删除 ---
export async function knowledgeRecommendIgnoreB(params) {
  return http.post('/learn/knowledge/cluster/delete', params);
}

// 知识库智能维护 问题推荐批量忽略
export async function knowledgeRecommendIgnores(params) {
  return http.post('/learn/knowledge/recommend/ignore', params);
}

// 知识库智能维护 问题推荐批量忽略 ---
export async function knowledgeRecommendIgnoresB(params) {
  return http.post('/learn/knowledge/cluster/ignore', params);
}

// 知识库智能维护 问题推荐信息
export async function knowledgeRecommendInfo(params) {
  return http.get('/learn/knowledge/recommend/info', params);
}

// 知识库智能维护 问题聚类信息 ---
export async function knowledgeRecommendInfoB(params) {
  return http.get('/learn/knowledge/cluster/info', params);
}

// 知识库智能维护 自定义问题导入模版
export async function maintainImportTemplate(params) {
  return http.downloadFile('/learn/knowledge/maintain/import/template', params);
}

// ---------------------------------------------

// 知识库智能维护 问题推荐的问题列表
export async function knowledgeRecommendQuestionList(params) {
  return http.post('/learn/knowledge/recommend/question/list', params);
}

// 知识库智能维护 问题聚类列表 ---
export async function knowledgeRecommendQuestionListB(params) {
  return http.post('/learn/knowledge/cluster/question/list', params);
}

// 知识库智能维护 问题推荐的问题批量忽略
export async function knowledgeRecommendQuestionignore(params) {
  return http.post('/learn/knowledge/recommend/question/ignore', params);
}

// 知识库智能维护 问题聚类批量忽略 ---
export async function knowledgeRecommendQuestionignoreB(params) {
  return http.post('/learn/knowledge/cluster/question/ignore', params);
}

// 知识库智能维护 问题推荐的问题批量删除
export async function knowledgerecommendquestiondelete(params) {
  return http.post('/learn/knowledge/recommend/question/delete', params);
}

// 知识库智能维护 问题聚类的问题批量删除 ---
export async function knowledgerecommendquestiondeleteB(params) {
  return http.post('/learn/knowledge/cluster/question/delete', params);
}

// 知识库智能维护 问题推荐的问题移至黑名单
export async function knowledgeRecommendQuestionBlacklist(params) {
  return http.post('/learn/knowledge/recommend/question/blacklist', params);
}

// 知识库智能维护 问题聚类的问题移至黑名单 ---
export async function knowledgeRecommendQuestionBlacklistB(params) {
  return http.post('/learn/knowledge/cluster/question/blacklist', params);
}

// 知识库智能维护 问题推荐 添加到推荐知识点
export async function knowledgeRecommendquestionrecommendQa(params) {
  return http.post('/learn/knowledge/recommend/question/recommendQa', params);
}

// 知识库智能维护 问题推荐 关联已有知识点
export async function knowledgeRecommendQuestionRelation(params) {
  return http.post('/learn/knowledge/recommend/question/relation', params);
}

// 知识库智能维护 问题聚类 关联已有知识点
export async function knowledgeRecommendQuestionRelationB(params) {
  return http.post('/learn/knowledge/cluster/question/relation', params);
}

// 知识库智能维护 问题推荐 下一个
export async function knowledgeRecommendQuestionNext(params) {
  return http.post('/learn/knowledge/recommend/question/next', params);
}

// 知识库智能维护 问题聚类 下一个
export async function knowledgeClusterQuestionNext(params) {
  return http.post('/learn/knowledge/cluster/question/next', params);
}

// 知识库智能维护 问题库 闲聊问题列表
export async function knowledgeQuestionChatList(params) {
  return http.post('/learn/knowledge/question/chat/list', params);
}

// 知识库智能维护 问题库 闲聊问题忽略
export async function knowledgeQuestionChatIgnore(params) {
  return http.post('/learn/knowledge/question/chat/ignore', params);
}

// 知识库智能维护 问题库 闲聊问题删除
export async function knowledgeQuestionChatDelete(params) {
  return http.post('/learn/knowledge/question/chat/delete', params);
}

// 知识库智能维护 问题库 闲聊问题移到黑名单
export async function knowledgeQuestionChatBlacklist(params) {
  return http.post('/learn/knowledge/question/chat/blacklist', params);
}

// 知识库智能维护 问题库 清除闲聊问题状态
export async function knowledgeQuestionChatStatus(params) {
  return http.post('/learn/knowledge/question/chat/status', params);
}

// 知识库智能维护 问题库 开始清除闲聊任务
export async function knowledgeQuestionChatSubmit(params) {
  return http.post('/learn/knowledge/question/chat/submit', params);
}

// 知识库智能维护 推荐任务任务进度
export async function knowledgerecommendProcess(params) {
  return http.get('/learn/knowledge/recommend/process', params);
}

// 知识库智能维护 聚类任进度
export async function knowledgeclusterProcess(params) {
  return http.get('/learn/knowledge/cluster/process', params);
}

// 知识库智能维护 清除闲聊任务
export async function knowledgequestionChatProcess(params) {
  return http.get('/learn/knowledge/question/chat/process', params);
}

// 知识库智能维护 获取问题库导入状态
export async function knowledgeMaintainImportStatus(params) {
  return http.get('/learn/knowledge/maintain/import/status', params);
}

// 知识库智能维护  获取问题库导入进度
export async function knowledgeMaintainImportProcess(params) {
  return http.get('/learn/knowledge/maintain/import/process', params);
}

// 知识库智能维护  导入自定义问题
export async function maintainImport(params) {
  return http.post('/learn/knowledge/maintain/import', params);
}

// 知识库智能维护 问题库 删除所有问题
export async function knowledgeQuestionClear(params) {
  return http.post('/learn/knowledge/question/clear', params);
}

// 知识库体验 获取相似问、异常问任务状态
export async function knowledEexamineChecksstatus(params) {
  return http.get('/learn/knowledge/examine/check/status', params);
}

// 智能学习-知识库智能维护_关联已有问题
export async function learnKnowledgeRecommendQuestionRelation(params) {
  return http.post('/learn/knowledge/recommend/question/relation', params);
}
